package com.dy.字符串.字符串中的第一个唯一字符;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/*
字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

案例:

s = "leetcode"
返回 0.

s = "loveleetcode",
返回 2.


注意事项：您可以假定该字符串只包含小写字母。
 */
public class Solution {
    public static int firstUniqChar(String s) {
        Map<Character,Integer> map = new LinkedHashMap<Character,Integer>();
        for(int i=0;i<s.length();i++){
            char tmp  = s.charAt(i);
            if(map.containsKey(tmp)){
                map.put(tmp,map.get(tmp)+1);
            }
            else
                map.put(tmp,1);

        }
        for(Map.Entry<Character,Integer> entry:map.entrySet()){
            System.out.println(entry.getKey()+" "+entry.getValue());
            if(entry.getValue()==1){
                return s.indexOf(entry.getKey());
            }

        }
        return -1;
    }
    //这里keyset顺序不确定
    public static int firstUniqChar2(String s) {
        Map<Integer,Character> map = new HashMap<>();

        for (int i = 0; i < s.length(); i++){
            map.put(i,s.charAt(i));
        }
        for (int i = 0; i < s.length(); i++){

            if (i != s.lastIndexOf(s.charAt(i)) ) {
                map.remove(i);
                map.remove(s.lastIndexOf(s.charAt(i)));
            }

        }

        if (map.isEmpty()){
            return -1;
        }else{
            for (Integer i : map.keySet()) {
                return i;
            }
        }
        return -1;
    }
    //只考虑26个字母
    public static int firstUniqChar3(String s) {
        int freq[] = new int[26];

        for (int i = 0; i < s.length(); i++)
            freq[s.charAt(i) - 'a']++;

        for (int i = 0; i < s.length(); i++)
            if (freq[s.charAt(i) - 'a'] == 1)
                return i;
        return -1;
    }
    //最简洁
    public static int firstUniqChar4(String s) {
        int res = -1;
        for (char ch = 'a'; ch <= 'z'; ch++) {
            int index = s.indexOf(ch);
            if (index != -1 && index == s.lastIndexOf(ch)) {
                res = (res == -1 || res > index) ? index : res;
            }
        }
        return res;


    }

}
